home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Source Code / C / Applications / Eudora 1.3.1 / source / buildtoc.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-03-16  |  17.6 KB  |  761 lines  |  [TEXT/MPS ]
  1. #define FILE_NUM 45
  2. /* Copyright (c) 1991-1992 by the University of Illinois Board of Trustees */
  3. #pragma load EUDORA_LOAD
  4. #pragma segment BuildTOC
  5.  
  6.     void GleanFrom(UPtr line,MSumPtr sum);
  7.     long BeautifyDate(UPtr dateStr,long *zoneSecs);
  8.     short SalvageTOC(TOCHandle old, TOCHandle new);
  9.     void TrimWrap(UPtr str,int openC,int closeC);
  10.     long UnixDate2Secs(PStr date);
  11.     short MonthNum(CStr cp);
  12.  
  13. /************************************************************************
  14.  * RebuildTOC - rebuild a corrupt or out-of-date toc, salvaging what we
  15.  * can.
  16.  ************************************************************************/
  17. TOCHandle ReBuildTOC(long dirId,UPtr name)
  18. {
  19.     short refN=0,err;
  20.     long size;
  21.     Str63 tocName;
  22.     TOCHandle newTocH=nil;
  23.     short oldCount, newCount, salvCount;
  24.     
  25.     /*
  26.      * read the old one into memory
  27.      */
  28.     PCopy(tocName,name); PCat(tocName,"\p.toc");
  29.     if (err=FSHOpen(tocName,MyVRef,dirId,&refN,fsRdPerm) ||
  30.             (err=GetEOF(refN,&size)))
  31.     {
  32.         if (err!=fnfErr) FileSystemError(READ_TOC,tocName,err);
  33.     }
  34.     else
  35.     {
  36.         DamagedTOC = NuHandle(size);
  37.         if (!DamagedTOC) WarnUser(READ_TOC,MemError());
  38.         else
  39.         {
  40.             if (err=FSRead(refN,&size,LDRef(DamagedTOC)))
  41.                 FileSystemError(READ_TOC,tocName,err);
  42.         }
  43.         FSClose(refN);
  44.     }
  45.     if (err==fnfErr) err = noErr;
  46.     
  47.     if (!err || AlertStr(TOC_SALV_ALRT,Stop,name)==OK)
  48.     {
  49.         /*
  50.             * build the new one
  51.             */
  52.         if ((newTocH = BuildTOC(dirId,name)) && !err && DamagedTOC)
  53.         {
  54.             oldCount = (*DamagedTOC)->count;
  55.             newCount = (*newTocH)->count;
  56.             if (oldCount && newCount)
  57.             {
  58.                 Str255 s;
  59.                 salvCount = SalvageTOC(DamagedTOC,newTocH);         /* and salvage */
  60.                 ComposeRString(s,SALV_REPORT,salvCount,oldCount,newCount-salvCount);
  61.                 AlertStr(OK_ALRT,Note,s);
  62.             }
  63.         }
  64.     }
  65.     
  66.     if (DamagedTOC) ZapHandle(DamagedTOC);
  67.     return(newTocH);
  68. }
  69.  
  70. /************************************************************************
  71.  * SalvageTOC - reconcile and old a new TOC
  72.  ************************************************************************/
  73. short SalvageTOC(TOCHandle old, TOCHandle new)
  74. {
  75.     short first,last,mid;
  76.     MSumPtr oldSum;
  77.     long offset;
  78.     short salvaged=0;
  79.     
  80.     LDRef(old); LDRef(new);
  81.     (*old)->count = (GetHandleSize(old)-(sizeof(TOCType)-sizeof(MSumType)))/
  82.                                     sizeof(MSumType);
  83.     
  84.     for (oldSum=(*old)->sums;oldSum<(*old)->sums+(*old)->count;oldSum++)
  85.     {
  86.         offset = oldSum->offset;
  87.         first = 0; last=(*new)->count-1;
  88.         for (mid=(first+last)/2;first<=last;mid=(first+last)/2)
  89.             if (offset<(*new)->sums[mid].offset)
  90.                 last = mid -1;
  91.             else if (offset==(*new)->sums[mid].offset)
  92.                 break;
  93.             else
  94.                 first = mid+1;
  95.         if (first<=last && (*new)->sums[mid].length==oldSum->length)
  96.         {
  97.             salvaged++;
  98.             (*new)->sums[mid] = *oldSum;
  99.         }
  100.     }
  101.     
  102.     UL(old); UL(new);
  103.     CleanseTOC(new);
  104.     return(salvaged);
  105. }
  106.  
  107. /**********************************************************************
  108.  * BuildTOC - build a table of contents for a file.  The TOC is built
  109.  * in memory.  This gets a little hairy in spots because the routine is
  110.  * used both for received messages and messages under composition; but
  111.  * the complication does not substantially affect the flow of the
  112.  * function, so I let it stand.
  113.  **********************************************************************/
  114. TOCHandle BuildTOC(long dirId,UPtr name)
  115. {
  116.     TOCHandle tocH=nil;
  117.     MSumType sum;
  118.     int err;
  119.     Boolean isOut;
  120.     Str255 scratch;
  121.     
  122.     /*
  123.      * first, try opening the file
  124.      */
  125.     if (err=OpenLine(MyVRef,dirId,name))
  126.     {
  127.         FileSystemError(OPEN_MBOX,name,err);
  128.         return(nil);
  129.     }
  130.     
  131.     if ((tocH=NewZHandle(sizeof(TOCType)))==nil)
  132.     {
  133.         WarnUser(READ_MBOX,MemError());
  134.         goto failure;
  135.     }
  136.     
  137.     /*
  138.      * figure out for once and for all if we are an in or an out box
  139.      */
  140.     isOut = False;
  141.     if (dirId==MyDirId)
  142.     {
  143.         GetRString(scratch,IN);
  144.         if (EqualString(scratch,name,False,True))
  145.             (*tocH)->which = IN;
  146.         else
  147.         {
  148.             GetRString(scratch,OUT);
  149.             if (EqualString(scratch,name,False,True))
  150.             {
  151.                 (*tocH)->which = OUT;
  152.                 isOut = True;
  153.             }
  154.             else
  155.             {
  156.                 GetRString(scratch,TRASH);
  157.                 if (EqualString(scratch,name,False,True))
  158.                     (*tocH)->which = TRASH;
  159.             }
  160.         }
  161.     }
  162.     
  163.     ReadSum(nil,False);
  164.     while (ReadSum(&sum,isOut))
  165.     {
  166.         if (!SaveMessageSum(&sum,tocH))
  167.         {
  168.             WarnUser(SAVE_SUM,MemError());
  169.             goto failure;
  170.         }
  171.     }
  172.     ReadSum(nil,False);
  173.  
  174.     /*
  175.      * success
  176.      */
  177.     CloseLine();
  178.     (*tocH)->refN = 0;
  179.     (*tocH)->vRef = MyVRef;
  180.     (*tocH)->dirId = dirId;
  181.     BlockMove(name,(*tocH)->name,*name+1L);
  182.     (*tocH)->version = 0;
  183.     (*tocH)->dirty = True;
  184.     SetHandleBig(tocH,sizeof(TOCType) + 
  185.         ((*tocH)->count ? (*tocH)->count-1 : 0)*sizeof(MSumType));
  186.     return (tocH);
  187.  
  188. failure:
  189.     if (tocH != nil) DisposHandle(tocH);
  190.     CloseLine();
  191.     return(nil);
  192. }
  193.  
  194.  /************************************************************************
  195.  * ReadSum - read a summary, from the current position in the lineio
  196.  * routines.
  197.  ************************************************************************/
  198. Boolean ReadSum(MSumPtr sum,Boolean isOut)
  199. { 
  200.     static int type;
  201.     Str255 line;
  202.     static UHandle oldLine=nil;
  203.     enum {BEGIN, IN_BODY, IN_HEADER} state;
  204.     Str63 duck;
  205.     long secs;
  206.     Str31 prior;
  207.     Boolean lookPrior;
  208.     long origZone;
  209.     
  210.     if (!sum)
  211.     {
  212.         if (oldLine)
  213.         {
  214.             DisposHandle(oldLine);
  215.             oldLine = nil;
  216.         }
  217.         return(True);
  218.     }
  219.     
  220.     /*
  221.      * set up the priority stuff
  222.      */
  223.     if (lookPrior = !PrefIsSet(PREF_NO_IN_PRIOR)) GetRString(prior,HEADER_STRN+PRIORITY_HEAD);
  224.  
  225.     /*
  226.      * now, read from it line by line
  227.      * break messages when sendmail-style From line is found
  228.      */
  229.     state = BEGIN;
  230.     WriteZero(sum,sizeof(MSumType));
  231.     sum->state = UNREAD;
  232.     sum->tableId = DEFAULT_TABLE;
  233.     while (oldLine || (type=GetLine(line,sizeof(line))))
  234.     {
  235.         if (oldLine)
  236.         {
  237.             BlockMove(*oldLine,line,sizeof(line));
  238.             DisposHandle(oldLine);
  239.             oldLine = nil;
  240.         }
  241.         switch(type)
  242.         {
  243.             case LINE_START:
  244.                 if (IsFromLine(line))
  245.                 {
  246.                     if (state!=BEGIN)
  247.                     {
  248.                         if ((oldLine=NuHandle(sizeof(line)))==nil)
  249.                         {
  250.                             WarnUser(MEM_ERR,MemError());
  251.                             return(False);
  252.                         }
  253.                         BlockMove(line,*oldLine,sizeof(line));
  254.                         return(True);
  255.                     }
  256.                     WriteZero(sum,sizeof(MSumType));
  257.                     sum->tableId = DEFAULT_TABLE;
  258.                     if (!isOut) GleanFrom(line,sum);
  259.                     sum->offset = TellLine();
  260.                     sum->state = isOut ? UNSENDABLE : UNREAD;
  261.                     state = IN_HEADER;
  262.                 }
  263.                 else if (state==IN_HEADER)
  264.                 {                                             /* look for date, subj, from lines */
  265.                     if (*line=='\n')
  266.                     {
  267.                         state = IN_BODY;
  268.                         sum->bodyOffset = TellLine()-sum->offset;
  269.                     }
  270.                     else if (!striscmp(line,"date:"))
  271.                     {
  272.                         CopyHeaderLine(duck,sizeof(duck),line);
  273.                         if (secs=BeautifyDate(duck,&origZone)) PtrTimeStamp(sum,secs,origZone);
  274.                         else
  275.                         {
  276.                             if (*duck > sizeof(sum->date)-2) *duck=sizeof(sum->date)-2;
  277.                             BlockMove(duck,sum->date,sizeof(sum->date));
  278.                         }
  279.                     }
  280.                     else if (!isOut && !striscmp(line,"from:"))
  281.                     {
  282.                         CopyHeaderLine(sum->from,sizeof(sum->from),line);
  283.                         BeautifyFrom(sum->from);
  284.                     }
  285.                     else if (isOut && !striscmp(line,"to:"))
  286.                     {
  287.                         CopyHeaderLine(sum->from,sizeof(sum->from),line);
  288.                         if (*sum->from) sum->state = SENDABLE;
  289.                     }
  290.                     else if (!striscmp(line,"subject:"))
  291.                     {
  292.                         CopyHeaderLine(sum->subj,sizeof(sum->subj),line);
  293.                     }
  294.                     else if (!striscmp(line,"status: r"))
  295.                         sum->state=READ;
  296.                     else if (lookPrior && !striscmp(line,prior+1))
  297.                         sum->priority = sum->origPriority = Display2Prior(atoi(line+*prior));
  298.                 }
  299.                 break;
  300.             case LINE_MIDDLE:
  301.                 break;
  302.             default:
  303.                 state=BEGIN;
  304.                 goto done;                     /* error message already given */
  305.                 break;
  306.         }
  307.         sum->length += strlen(line);
  308.         if (state==BEGIN) state=IN_HEADER;
  309.     }
  310. done:
  311.     return(state!=BEGIN);
  312. }
  313.  
  314. /**********************************************************************
  315.  * BeautifySum - beautify a message summary before saving it.  This
  316.  * involves beautifying the from address and the date.
  317.  **********************************************************************/
  318. void BeautifySum(MSumPtr sum)
  319. {
  320.     if (sum->seconds) PtrTimeStamp(sum,sum->seconds,ZoneSecs());
  321.     BeautifyFrom(sum->from);
  322. }
  323.  
  324. /**********************************************************************
  325.  * IsFromLine - determine whether or not a given line is a sendmail From
  326.  * line.
  327.  **********************************************************************/
  328. Boolean IsFromLine(UPtr line)
  329. {
  330.     int num,len;
  331.     int quote=0;
  332.     Str255 scratch;
  333.     UPtr cp;
  334.     short weekDay,year,tym,day,month,other,remote,from;
  335.  
  336. #define isdig(c) ('0'<=(c) && (c)<='9') 
  337.     if (line[0]!='F' || line[1]!='r' || line[2]!='o' || line[3]!='m')
  338.         return (False);  /* quick and dirty */
  339.     
  340.     /*
  341.      * it passed the first test.    Now, we have to be more rigorous.
  342.      * this is a sample sendmail From line:
  343.      * >From paul@uxc.cso.uiuc.edu Wed Jun 14 12:36:18 1989<
  344.      * However, various systems do various bad things with the From line.
  345.      * therefore, I've changed it to look for:
  346.      */
  347.     
  348.     /* check for the space after the from */
  349.     line += 4;
  350.     if (*line++!=' ') return (False);
  351.     
  352.     /* skip the return address */
  353.     while (*line && (quote || *line!=' '))
  354.     {
  355.         if (*line=='"') quote = !quote;
  356.         line++;
  357.     }
  358.     if (!*line++) return (False);
  359.     while (*line==' ') line++;
  360.     
  361.     remote=from=weekDay=day=from=year=tym=month=other=0;
  362.     len = strlen(line);
  363.     if (len>sizeof(scratch)-1) return(False);
  364.     strcpy(scratch,line);
  365.     for (cp=strtok(scratch," \t\n,");cp;cp=strtok(nil," \t\n,"))
  366.     {
  367.         len = strlen(cp);
  368.         num = atoi(cp);
  369.         if (num<24 && (len>=5 && cp[2]==':') && (len==5 || len==8 && cp[5]==':'))
  370.         {
  371.             if (tym++) return(False);
  372.         }
  373.         else if (!year && day && len==2 && isdig(cp[len-1]))
  374.         {
  375.             if (year++) return(False);
  376.         }
  377.         else if (len<=2 && num && num<32)
  378.         {
  379.             if (day++) return(False);
  380.         }
  381.         else if (len==4&&num>1900)
  382.         {
  383.             if (year++) return(False);
  384.         }
  385.         else if (len==6 && !striscmp(cp,"remote"))
  386.         {
  387.             if (remote++ || from) return(False);
  388.         }
  389.         else if (len==4 && !striscmp(cp,"from"))
  390.         {
  391.             if (!remote || from++) return(False);
  392.         }
  393.         else if (len==3 &&
  394.             !(striscmp(cp,"mon") && striscmp(cp,"tue") && striscmp(cp,"wed")
  395.              && striscmp(cp,"thu") && striscmp(cp,"fri")
  396.              && striscmp(cp,"sat") && striscmp(cp,"sun")))
  397.         {
  398.             if (weekDay++) return(False);
  399.         }
  400.         else if (len==3 && !(striscmp(cp,"jan") && striscmp(cp,"feb") &&
  401.             striscmp(cp,"mar") && striscmp(cp,"apr") &&
  402.             striscmp(cp,"may") && striscmp(cp,"jun") &&
  403.             striscmp(cp,"jul") && striscmp(cp,"aug") &&
  404.             striscmp(cp,"sep") && striscmp(cp,"oct") &&
  405.             striscmp(cp,"nov") && striscmp(cp,"dec")))
  406.         {
  407.             if (month++) return(False);
  408.         }
  409.         else
  410.         {
  411.             other++;
  412.         }
  413.     }
  414.     return (day && year && month && tym && other<=2);
  415. }
  416. /**********************************************************************
  417.  * GleanFrom - grab relevant info from sendmail From line
  418.  * input line is in C format, fields in summary are in Pascal form
  419.  **********************************************************************/
  420. void GleanFrom(UPtr line,MSumPtr sum)
  421. {
  422.     Str255 copy;
  423.     register char *cp=copy;
  424.     register char *ep;
  425.     long seconds;
  426.     long offset = ZoneSecs();
  427.     
  428.     strcpy(copy,line);
  429.     /*
  430.      * from address
  431.      */
  432.     while (*cp++ != ' ');
  433.     for (ep=cp; *ep!= ' '; ep++);
  434.     *ep = '\0';
  435.     MakePStr(sum->from,cp,ep-cp);
  436.     
  437.     /*
  438.      * date
  439.      */
  440.     for (cp=++ep;*ep!='\n' && *ep; ep++);
  441.     *ep = '\0';
  442.     MakePStr(sum->date,cp,ep-cp);
  443.     
  444.     /*
  445.      * TimeStamp
  446.      */
  447.     seconds = UnixDate2Secs(sum->date)-offset;
  448.     PtrTimeStamp(sum,seconds,offset);
  449. }
  450.  
  451.  
  452. /************************************************************************
  453.  * UnixDate2Secs - convert a UNIX date into seconds
  454.  ************************************************************************/
  455. long UnixDate2Secs(PStr date)
  456. {
  457.     Str63 copy;
  458.     UPtr end;
  459.     DateTimeRec dtr;
  460.     long secs = 0;
  461.     
  462.     PCopy(copy,date);
  463.     end = copy+*copy;
  464.     /* let's null-terminate this, shall we? */
  465.     end[1] = 0;
  466.     
  467.     /* back up and grab the year */
  468.     while (*end!=' ' && end>copy) end--;
  469.     dtr.year = atoi(end);
  470.     if (dtr.year>0 && dtr.year<1900) dtr.year+=1900;
  471.     
  472.     /* seconds */
  473.     *end = 0;
  474.     while (*end!=':'&&end>copy) end--;
  475.     dtr.second = atoi(end+1);
  476.     
  477.     /* minutes */
  478.     *end = 0;
  479.     while (*end!=':'&&end>copy) end--;
  480.     dtr.minute = atoi(end+1);
  481.     
  482.     /* hours */
  483.     *end = 0;
  484.     while (*end!=' '&&end>copy) end--;
  485.     dtr.hour = atoi(end+1);
  486.     
  487.     /* date */
  488.     *end = 0;
  489.     while (*end!=' '&&end>copy) end--;
  490.     dtr.day = atoi(end+1);
  491.  
  492.     /* Month */
  493.     *end = 0;
  494.     while (*--end==' ' && end>=copy);
  495.     while (*end!=' '&&end>copy) end--;
  496.     dtr.month = MonthNum(end+1);
  497.     
  498.     if (dtr.year && dtr.month) Date2Secs(&dtr,&secs);
  499.     return(secs);
  500. }
  501.  
  502. /************************************************************************
  503.  * MonthNum - get the month number from a month name
  504.  ************************************************************************/
  505. short MonthNum(CStr cp)
  506. {
  507.     char monthStr[4];
  508.     short month=0;
  509.     
  510.     /*
  511.      * copy and lowercase
  512.      */
  513.     BlockMove(cp,monthStr,3);
  514.     monthStr[3] = 0;
  515.     for (cp=monthStr;*cp;cp++) if (isupper(*cp)) *cp = tolower(*cp);
  516.     cp = monthStr;
  517.     
  518.     switch(cp[0])
  519.     {
  520.         case 'j': month = cp[1]=='a' ? 1 : (cp[2]=='n' ? 6 : 7); break;
  521.         case 'f': month = 2; break;
  522.         case 'm': month = cp[2]=='r' ? 3 : 5; break;
  523.         case 'a': month = cp[1]=='p' ? 4 : 8; break;
  524.         case 's': month = 9; break;
  525.         case 'o': month = 10; break;
  526.         case 'n': month = 11; break;
  527.         case 'd': month = 12; break;
  528.     }
  529.     return(month);
  530. }
  531.  
  532. /************************************************************************
  533.  * BeautifyDate - make a date look better
  534.  * assumes the date is in smtp date format
  535.  ************************************************************************/
  536. long BeautifyDate(UPtr dateStr,long *origZone)
  537. {
  538.     UPtr cp, cp2;
  539.     DateTimeRec dtr;
  540.     long secs;
  541.     long offset;
  542.     *origZone = 0;
  543.     
  544.     if (*dateStr < 10) return(0);  /* ignore really short dates */
  545.     dateStr[*dateStr+1] = 0;
  546.     WriteZero(&dtr,sizeof(dtr));
  547.     
  548.     /*
  549.      * delete day of the week
  550.      */
  551.     if (cp=strchr(dateStr+1,','))
  552.     {
  553.         for (cp++;isspace(*cp);cp++);
  554.         strcpy(dateStr+1,cp);
  555.         *dateStr = strlen(dateStr+1);
  556.     }
  557.     
  558.     /*
  559.      * make sure that single-digit dates begin with a space, not a '0' and
  560.      * not nothing
  561.      */
  562.     dtr.day = atoi(dateStr+1);
  563.     if (dateStr[1]=='0')
  564.         dateStr[1] = ' ';
  565.     else if (dateStr[2]==' ')
  566.     {
  567.         Str255 temp;
  568.         *temp = 1;
  569.         PCat(temp,dateStr);
  570.         PCopy(dateStr,temp);
  571.         dateStr[1] = ' ';
  572.     }
  573.         
  574.     /*
  575.      * delete year, if present
  576.      */
  577.     /* pointing at day */
  578.     for (cp=dateStr+2;*cp && !isspace(*cp);cp++);
  579.     for (;isspace(*cp);cp++);
  580.     /* pointing at month */
  581.     dtr.month = MonthNum(cp);
  582.     for (;*cp && !isspace(*cp);cp++);
  583.     for (cp2=cp;isspace(*cp2);cp2++);
  584.     
  585.     if (*cp && isdigit(*cp2))
  586.     {
  587.         dtr.year = atoi(cp2);
  588.         if (dtr.year<20) dtr.year += 2000;
  589.         else if (dtr.year<1900) dtr.year += 1900;
  590.         while (isdigit(*cp2)) cp2++;
  591.         strcpy(cp,cp2);
  592.         *dateStr -= cp2-cp;
  593.         dateStr[*dateStr+1] = 0;
  594.     }
  595.     
  596.     /*
  597.      * delete the seconds, if present
  598.      */
  599.     dtr.hour = atoi(cp);
  600.     if (cp=strchr(cp,':'))
  601.     {
  602.         dtr.minute = atoi(cp+1);
  603.         if (cp[3]==':')
  604.         {
  605.             dtr.second = atoi(cp+4);
  606.             strcpy(cp+3,cp+6);
  607.             *dateStr -= 3;
  608.             dateStr[*dateStr+1] = 0;
  609.         }
  610.     }
  611.     
  612.     if (dtr.year)
  613.     {
  614.         Date2Secs(&dtr,&secs);
  615.         cp = strchr(dateStr+1,':');
  616.         cp2 = dateStr+*dateStr+1;
  617.         if (cp&&cp+4<cp2)
  618.         {
  619.             cp+=4;
  620.             if (offset = atoi(cp))
  621.             {
  622.                 if (*cp == '-') offset *= -1;
  623.                 offset = (3600 * offset)/100 + 60*(offset%100);
  624.                 if (*cp == '-') offset *= -1;
  625.             }
  626.             else
  627.             {
  628.                 offset = TZName2Offset(cp);
  629.             }
  630.         }
  631.         else
  632.             offset = ZoneSecs();
  633.         secs -= offset;
  634.         *origZone = offset;
  635.     }
  636.     else secs = 0;
  637.     return(secs);
  638. }
  639.  
  640. /************************************************************************
  641.  * BeautifyFrom - make a from line look better
  642.  ************************************************************************/
  643. void BeautifyFrom(UPtr fromStr)
  644. {
  645.     UPtr cp1,cp2;
  646.     int len;
  647.     
  648.     fromStr[*fromStr+1] = 0;
  649.     
  650.     /*
  651.      * elide <>'ed text, unless it's all there is
  652.      */
  653.     TrimWhite(fromStr);
  654.     if (cp1=strchr(fromStr+1,'<'))
  655.     {
  656.         if (cp2=strchr(cp1+1,'>'))
  657.         {
  658.             while (cp2[1]==' ') cp2++;
  659.             len = cp2 - cp1 - 1;
  660.             if (len>0 && len < *fromStr-2)
  661.             {
  662.                 strcpy(cp1,cp2+1);
  663.                 *fromStr -= len+2;
  664.             }
  665.         }
  666.     }
  667.     /*
  668.      * prefer parenthesized text
  669.      */
  670.     else if (cp1=strchr(fromStr+1,'('))
  671.         if (cp2=strchr(cp1+1,')'))
  672.         {
  673.             len = cp2 - cp1 - 1;
  674.             if (len>0)
  675.             {
  676.                 *fromStr = len;
  677.                 strncpy(fromStr+1,cp1+1,len);
  678.                 fromStr[*fromStr+1] = 0;
  679.             }
  680.         }
  681.     TrimWhite(fromStr);
  682.     TrimWrap(fromStr,'(',')');
  683.     TrimWrap(fromStr,'"','"');
  684. }
  685.  
  686. void TrimWrap(UPtr str,int openC,int closeC)
  687. {
  688.   if (*str>1 && str[1] == openC && str[*str] == closeC)
  689.     {
  690.       BlockMove(str+2,str+1,*str-2);
  691.         *str -= 2;
  692.         str[*str+1] = 0;
  693.     }
  694. }
  695.     
  696. /************************************************************************
  697.  * SumToFrom - build a sendmail-style from line from a message summary
  698.  ************************************************************************/
  699. int SumToFrom(MSumPtr sum, UPtr fromLine)
  700. {
  701.     char *start, *end;
  702.     Str31 delims;
  703.     Str63 fromWhom;
  704.     short n;
  705.     
  706.     GetRString(delims,DELIMITERS);
  707.     if (sum && Tokenize(sum->from+1,*sum->from,&start,&end,delims))
  708.     {
  709.         strncpy(fromWhom+1,start,end-start);
  710.         *fromWhom = end-start;
  711.     }
  712.     else
  713.         GetRString(fromWhom,UNKNOWN_SENDER);
  714.  
  715.     PCopy(fromLine,"\pFrom ");
  716.     PCat(fromLine,fromWhom);
  717.     n = fromLine[0]+1;
  718.     LocalDateTimeStr(fromLine+n);
  719.     fromLine[0] += fromLine[n]+1;
  720.     fromLine[n] = ' ';
  721.     p2cstr(fromLine);
  722.     return(strlen(fromLine));
  723. }
  724.  
  725. /**********************************************************************
  726.  * CopyHeaderLine - copy the contents of a header line (C format)
  727.  * into a Pascal string.
  728.  **********************************************************************/
  729. void CopyHeaderLine(UPtr to,int size,UPtr from)
  730. {
  731.     while (*from++ != ':');
  732.     for (from++; *from == ' '; from++);
  733.     strncpy(to,from,size-2);
  734.     to[size-2] = 0;
  735.     c2pstr(to);
  736.     TrimWhite(to);
  737. } 
  738.  
  739. /************************************************************************
  740.  * FindTOCSpot - find a spot in a file that's big enough to hold a
  741.  * message.
  742.  ************************************************************************/
  743. long FindTOCSpot(TOCHandle tocH, long length)
  744. {
  745. #pragma unused(length)
  746.     long end=0;
  747.     MSumPtr sum;
  748.     MSumPtr limit;
  749.     
  750.     /*
  751.      * for now, just return the end
  752.      */
  753.     sum = (*tocH)->sums;
  754.     limit = sum + (*tocH)->count;
  755.     for (; sum<limit ; sum++)
  756.         if (end < sum->offset+sum->length)
  757.             end = sum->offset + sum->length;
  758.     
  759.     return(end);
  760. }
  761.